package almacenamiento;

import java.util.Random;

import org.cocos2d.actions.CCProgressTimer;
import org.cocos2d.actions.instant.CCCallFuncN;
import org.cocos2d.actions.instant.CCToggleVisibility;
import org.cocos2d.actions.interval.CCMoveTo;
import org.cocos2d.actions.interval.CCSequence;
import org.cocos2d.layers.CCLayer;
import org.cocos2d.layers.CCScene;
import org.cocos2d.nodes.CCDirector;
import org.cocos2d.nodes.CCSprite;
import org.cocos2d.types.CGPoint;
import org.cocos2d.types.CGSize;

import com.example.proyectofc.Utilidades;
import com.example.proyectofc.juego;

import procesamiento.utilidadesPartida;

import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Handler;
import android.view.MotionEvent;

public class capaJuego extends CCLayer {
	 Random rand = new Random();
	 
//	 private int porcentaje = 0; 


	 
	 private boolean estado = false, mostrarBocadillo = true, 
			 mostrarDialogo = false;
	 CCSprite fondo, jugador, ojosAbiertos, ojosCerrados, bocaAbierta,
	 bocaCerrada, bocadilloHola, bocadilloAventura, bocadilloPregunta, nube1, 
	 nube2, nube3, nube4, nube5, borde, bocadilloP1, bocadilloIndicacion;
	 CCProgressTimer nivel;
	 CGSize tamañoVentana;

	 
	 static float[] escalado;
	 int numeroPrueba;
	 
	 final Handler manejador = new Handler();
	 
	public capaJuego() {
		
		setIsTouchEnabled(true);
		if(utilidadesPartida.esPartidaVacia()) {
			utilidadesPartida.crearPartida(Utilidades.getUsuarioJugador()
					.getNombre());
		}
		numeroPrueba = utilidadesPartida.getDatosPartida().getnPrueba();
		tamañoVentana = CCDirector.sharedDirector().displaySize();
		
		escalado = utilidadesPartida.calcularPatronEscalado(
				tamañoVentana.getHeight(), tamañoVentana.getWidth());
	    
	    jugador = CCSprite.sprite("BichoBola.png");
	    ojosAbiertos = CCSprite.sprite("ojosAbiertos.png");
	    ojosCerrados = CCSprite.sprite("ojosCerrados.png");
	    bocaAbierta = CCSprite.sprite("bocaAbierta.png");
	    bocaCerrada = CCSprite.sprite("bocaCerrada.png");
	    
	    bocadilloHola = CCSprite.sprite("bocHola.png");
	    bocadilloAventura = CCSprite.sprite("bocAventura.png");
	    bocadilloPregunta = CCSprite.sprite("bocPregunta.png");
	    bocadilloIndicacion = CCSprite.sprite("bocIndicacion.png");
	    bocadilloP1 = CCSprite.sprite("bocP1.png");
	    
	    nube1 = CCSprite.sprite("nub1.png");
	    nube2 = CCSprite.sprite("nub2.png");
	    nube3 = CCSprite.sprite("nub3.png");
	    nube4 = CCSprite.sprite("nub4.png");
	    nube5 = CCSprite.sprite("nub5.png");
	    
	    borde = CCSprite.sprite("bordeBarra.png");
	    nivel = CCProgressTimer.progress("barra.png");
	    
	    borde.setPosition(tamañoVentana.width/2+30, tamañoVentana.height-20);
	    addChild(borde);
	    
	    nivel.setAnchorPoint(0, 0);
	    nivel.setType(CCProgressTimer.kCCProgressTimerTypeHorizontalBarLR);
	    nivel.setPercentage(utilidadesPartida.devolverPorcentaje());
	    borde.addChild(nivel);
	    
	    nube1.setPosition(-20, 10);
	    borde.addChild(nube1);
	    nube2.setPosition(-20, 10);
	    borde.addChild(nube2);
	    nube3.setPosition(-20, 10);
	    borde.addChild(nube3);
	    nube4.setPosition(-20, 10);
	    borde.addChild(nube4);
	    nube5.setPosition(-20, 10);
	    borde.addChild(nube5);
	    
	    elegirNube();
	    
	    jugador.setPosition(0, 150);
	    addChild(jugador);
	    
	    bocaAbierta.setPosition(158, 290);
//	    bocaAbierta.setVisible(!estado);
	    bocaCerrada.setPosition(158, 290);
	    bocaCerrada.setVisible(false);
	    ojosAbiertos.setPosition(158, 320);
//	    ojosAbiertos.setVisible(!estado);
	    ojosCerrados.setPosition(158, 320);
	    ojosCerrados.setVisible(false);
	    
	    jugador.addChild(ojosAbiertos);
	    jugador.addChild(ojosCerrados);
	    jugador.addChild(bocaAbierta);
	    jugador.addChild(bocaCerrada);
	    
	    bocadilloHola.setPosition(190, 400);
	    jugador.addChild(bocadilloHola);
	    bocadilloHola.setVisible(false);

	    bocadilloAventura.setPosition(190, 400);
	    jugador.addChild(bocadilloAventura);
	    bocadilloAventura.setVisible(false);
	    
	    bocadilloPregunta.setPosition(190, 400);
	    jugador.addChild(bocadilloPregunta);
	    bocadilloPregunta.setVisible(false);
	    
	    bocadilloIndicacion.setPosition(190, 400);
	    jugador.addChild(bocadilloIndicacion);
	    bocadilloIndicacion.setVisible(false);
	    
	    bocadilloP1.setPosition(190, 400);
	    jugador.addChild(bocadilloP1);
	    bocadilloP1.setVisible(false);
	    
	    int velocidad = 50;
//	    int duracion = (int)(CGPoint.ccpDistance(jugador.getPosition(), 
//	    		CGPoint.ccp(170.0f, 150.0f))) / velocidad;
	    
	    int duracion = (int)(CGPoint.ccpDistance(jugador.getPosition(), 
	    		CGPoint.ccp(tamañoVentana.width - 
	    				jugador.getContentSize().width/2 + 10, 150.0f))) 
	    				/ velocidad;
	    entrar(duracion, tamañoVentana);	
	}
	
	public static CCScene escena() {
		CCScene escena = CCScene.node();
		CCLayer capa = new capaJuego();

		CCLayer capaFondo = new capaFondo(escalado[0], escalado[1]);
		escena.addChild(capaFondo);
		escena.addChild(capa);
		
		return escena;
	}
	
	public void entrar(int duracion, CGSize tamVentana) {
		
	    CCMoveTo accion = CCMoveTo.action(duracion, 
	    		CGPoint.ccp(tamVentana.width - jugador.getContentSize().width 
	    				/ 2 + 10, 150));
	    CCCallFuncN accionTerminada = CCCallFuncN.action(this, 
	    		"presentacion");
	    CCSequence actions = CCSequence.actions(accion, accionTerminada);
	    
	    jugador.runAction(actions);
	}
	
	
	public void parpadear(){
		
		CCToggleVisibility abOj = new CCToggleVisibility();
		abOj.start(ojosAbiertos);
		
		CCToggleVisibility ceOj = new CCToggleVisibility();
		ceOj.start(ojosCerrados);
		
		CCSequence parpadear = CCSequence.actions(ceOj, abOj);
		
		jugador.runAction(parpadear);	   
	}
	
	public void moverBoca() {
		
		CCToggleVisibility abBo = new CCToggleVisibility();
		abBo.start(bocaAbierta);
		
		CCToggleVisibility ceBo = new CCToggleVisibility();
		ceBo.start(bocaCerrada);
		
		CCSequence moverBoca = CCSequence.actions(abBo, ceBo);
		
		jugador.runAction(moverBoca);
	}
	
	public void presentacion(Object ob) {
		CCCallFuncN gesticular = CCCallFuncN.action(this, 
	    		"hiloParalelo");
		
		jugador.runAction(gesticular);
	}
	
	public void elegirNube() {
		 if (utilidadesPartida.esPartidaVacia() || 
		    		utilidadesPartida.devolverNivel() == 1) {
		    	nube2.setVisible(false);
		    	nube3.setVisible(false);
		    	nube4.setVisible(false);
		    	nube5.setVisible(false);
		    }
		    else if (utilidadesPartida.devolverNivel() == 2) {
		    	nube1.setVisible(false);
		    	nube3.setVisible(false);
		    	nube4.setVisible(false);
		    	nube5.setVisible(false);
		    }
		    else if (utilidadesPartida.devolverNivel() == 3) {
		    	nube1.setVisible(false);
		    	nube2.setVisible(false);
		    	nube4.setVisible(false);
		    	nube5.setVisible(false);
		    }
		    else if (utilidadesPartida.devolverNivel() == 4) {
		    	nube1.setVisible(false);
		    	nube2.setVisible(false);
		    	nube3.setVisible(false);
		    	nube5.setVisible(false);
		    }
		    else if (utilidadesPartida.devolverNivel() == 5) {
		    	nube1.setVisible(false);
		    	nube2.setVisible(false);
		    	nube3.setVisible(false);
		    	nube4.setVisible(false);
		    }
	}
	
	public void hiloParalelo(Object o) {
		Thread hilo = new Thread() {
			public void run() {
				manejador.post(accion);
			}
		};
	
		hilo.start();	
	}

	final Runnable accion = new Runnable() {

		@Override
			public void run() {
				try {
					parpadear();
					Thread.sleep(500);
					parpadear();
					Thread.sleep(500);
					moverBoca();
					bocadilloHola.setVisible(true);
					Thread.sleep(800);
					moverBoca();
					Thread.sleep(800);
					moverBoca();
					Thread.sleep(800);
					parpadear();
					Thread.sleep(500);
					parpadear();
					Thread.sleep(500);
					moverBoca();
					bocadilloHola.setVisible(false);
					bocadilloAventura.setVisible(true);
					Thread.sleep(800);
					moverBoca();
					Thread.sleep(800);
					moverBoca();
					Thread.sleep(800);
					moverBoca();
					Thread.sleep(800);
					moverBoca();
					bocadilloAventura.setVisible(false);
					bocadilloPregunta.setVisible(true);
					Thread.sleep(500);
					parpadear();
					Thread.sleep(500);
					parpadear();
					Thread.sleep(500);
					bocadilloPregunta.setVisible(false);
					bocadilloIndicacion.setVisible(true);
					Thread.sleep(500);
					parpadear();
					Thread.sleep(500);
					parpadear();
					Thread.sleep(500);
					bocadilloIndicacion.setVisible(false);
					Thread.sleep(500);
					parpadear();
					Thread.sleep(500);
					parpadear();
					Thread.sleep(500);
					estado = true;
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
	
		}
	};

	@Override
	public boolean ccTouchesEnded(MotionEvent event) {
	    hayPulsacion();
		return super.ccTouchesEnded(event);
	}
	
	public void hayPulsacion() {
		
		if(estado && mostrarBocadillo ) {
			mostrarBocadilloPrueba(numeroPrueba + 1);
			mostrarBocadillo  = !mostrarBocadillo;
			mostrarDialogo  = !mostrarDialogo;
		}
		else if(estado && mostrarDialogo ) {
			mostrarDialogo();
			mostrarBocadillo  = !mostrarBocadillo;
			mostrarDialogo  = !mostrarDialogo;
		}
	}
	
	public void mostrarDialogo() {
		CCDirector.sharedDirector().getActivity().runOnUiThread(
				new Runnable(){
					public void run() {
						AlertDialog.Builder dialogo = 
								new AlertDialog.Builder(
										CCDirector.sharedDirector()
										.getActivity());
						dialogo.setMessage("La prueba consiste en:" + "\n-" +
								utilidadesPartida.devolverEjercicio(
										numeroPrueba + 1) + "\n\n" + "Pulse " +
												"Continuar para comenzar.");
						dialogo.setCancelable(false);
						dialogo.setPositiveButton("Continuar", 
								new DialogInterface.OnClickListener() {
							public void onClick(DialogInterface dialog, 
									int id) {
								hiloPrueba();
								}
							});
						dialogo.setNegativeButton("Cancelar", 
								new DialogInterface.OnClickListener() {
							public void onClick(DialogInterface dialog, 
									int id) {
								mostrarDialogo = true;
								mostrarBocadillo = false;
								dialog.cancel();
								}
							});
	                AlertDialog dialogoPopUp = dialogo.create();
	                dialogoPopUp.show();
	            }
	        });
	}
	
//	public void mostrarDialogoPruebaPar() {
//		CCDirector.sharedDirector().getActivity().runOnUiThread(
//				new Runnable(){
//					public void run() {
//
//					AlertDialog.Builder dialogo = 
//								new AlertDialog.Builder(
//										CCDirector.sharedDirector()
//										.getActivity());
//						
//						dialogo.setCancelable(false);
//						dialogo.setPositiveButton("Encontrado", 
//								new DialogInterface.OnClickListener() {
//							public void onClick(DialogInterface dialog, 
//									int id) {
////								juego.Camara();
//								Intent intent = new Intent(CCDirector
//										.sharedDirector().getActivity(), 
//										camara.class);
//								CCDirector.sharedDirector().onPause();
//								CCDirector.sharedDirector().getActivity()
//								.startActivity(intent);
//								}
//							});
//						 AlertDialog dialogoPopUp = dialogo.create();
//						 dialogoPopUp.show();
//	            }
//	        });		
//	}
	
	public void mostrarDialogoPruebaImpar() {
		CCDirector.sharedDirector().getActivity().runOnUiThread(
				new Runnable(){
					public void run() {
						AlertDialog.Builder dialogo = 
								new AlertDialog.Builder(
										CCDirector.sharedDirector()
										.getActivity());
						dialogo.setMessage("Pulsa Finalizar cuando hayas " +
								"acabado.");
						dialogo.setCancelable(false);
						dialogo.setPositiveButton("Finalizar", 
								new DialogInterface.OnClickListener() {
							public void onClick(DialogInterface dialog, 
									int id) {
								if(utilidadesPartida.manejarPruebaImpar(
										numeroPrueba + 1)){
									
								}
							}
						});
	                AlertDialog dialogoPopUp = dialogo.create();
	                dialogoPopUp.show();
	            }
	        });
	}
	
	public void mostrarCamara() {
		CCDirector.sharedDirector().getActivity().runOnUiThread(
				new Runnable(){
					public void run() {
	            }
	        });
	}
	
	public void mostrarBocadilloPrueba(int nPrueba) {
		bocadilloP1.setVisible(true);
	}
	
	protected void hiloPrueba() {
		Thread hilo = new Thread() {
			public void run() {
				manejador.post(accionGrabar);
			}
		};
	
		hilo.start();
	}

	final Runnable accionGrabar = new Runnable() {

		@Override
		public void run() {
			
			
			if((numeroPrueba + 1) % 2 == 1) {
				juego.comenzarGrabarDatos();
				boolean conseguido = juego.pruebaPar();
//				utilidadesPartida.manejarPruebaPar(numeroPrueba+1);
			}
			
			else if ((numeroPrueba + 1) % 2 == 0) {
				juego.comenzarGrabarDatos();
				mostrarDialogoPruebaImpar();
			}
		}
	
	};
	

	
//	public Bitmap redimensionarFondo (Context ctx, int resId,  float nuevaAnchura, 
//			float nuevaAltura){
//		
//		 Bitmap mBitmap = BitmapFactory.decodeResource(ctx.getResources(),
//                 resId);
		   //Redimensionamos
//		   int width = mBitmap.getWidth();
//		   int height = mBitmap.getHeight();
//		   float scaleWidth = ((float) nuevaAnchura) / width;
//		   float scaleHeight = ((float) nuevaAltura) / height;
		   // create a matrix for the manipulation
//		   Matrix matrix = new Matrix();
		   // resize the bit map
//		   matrix.postScale(scaleWidth, scaleHeight);
		   // recreate the new Bitmap
//		   return Bitmap.createBitmap(mBitmap, 0, 0, 
//				   width, height, matrix, false);
//	}
	
//	public void spriteMoveFinished (Object ob) {
//		int contador = 100000;
//		while (contador > 0) {
//			contador--;
//		}
//		gesticular();
//	}
//	
//	public void otraVez(Object ob) {
//		int contador = 1000000;
//		while (contador > 0) {
//			contador--;
//		}
//		gesticular2();
//	}
	
//	public static void setConexionBaseDatos(UtilidadesBaseDatos u) {
//		conexionBaseDatos = u;
//	}
}
